home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / audio / bz / bzwho.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  5.7 KB  |  272 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /***************************************************************************
  18.  * @(#) - BZWHO - Multiplayer tank game inquirer.
  19.  *
  20.  * $Id: bzwho.c,v 1.4 1993/08/11 19:46:47 adele Exp $
  21.  *
  22.  *                    Chris Fouts - Silicon Graphics, Inc.
  23.  *                    October, 1991
  24.  **************************************************************************/
  25. #include <stdio.h>
  26. #include <unistd.h>
  27. #include <stdlib.h>
  28. #include <fcntl.h>
  29. #include <errno.h>
  30. #include <bstring.h>
  31. #include <sys/types.h>
  32. #include <sys/socket.h>
  33. #include <netinet/in.h>
  34. #include <netdb.h>
  35. #include <arpa/inet.h>
  36.  
  37.  
  38. #include "bz.h"
  39. #include "multicast.h"
  40.  
  41. /* BEGIN PROTOTYPES -S bzwho.c */
  42. /* END PROTOTYPES -S bzwho.c */
  43.  
  44. static char    *version_id = "$Id: bzwho.c,v 1.4 1993/08/11 19:46:47 adele Exp $" ;
  45.  
  46.  
  47. struct BzMember                player[MAXPLAYERS] ;
  48. unsigned short                key[MAXPLAYERS] ;
  49. static unsigned                number_players ;
  50. static int                    in_fd ;
  51. static int                    in_addrlen ;
  52. static struct sockaddr_in    in_addr ;
  53. static char                    *teamName[] = { "Green", "Red", "Blue" } ;
  54.  
  55.  
  56. main(
  57.     int argc,
  58.     char **argv
  59.     )
  60. {
  61.     int                i ;
  62.     int                j = 0 ;
  63.     int                k ;
  64.     int                id ;
  65.     struct in_addr    addr ;
  66.     struct hostent    *hp ;
  67.  
  68.     number_players = 1 ;
  69.  
  70.     init_com() ;
  71.  
  72.     for( i = 0 ; i < 3 ; i++ ) {
  73.         sleep( 1 ) ;
  74.         network_in() ;
  75.         }
  76.  
  77.     if( number_players > 1 ) {
  78.  
  79.         for( i = 1 ; i < number_players ; i++ ) {
  80.             for( k = 0 ; k < j ; k++ ) {
  81.                 if( player[i].key == key[k] )
  82.                     break ;
  83.                 }
  84.             if( k == j ) {
  85.                 key[j++] = player[i].key ;
  86.                 }
  87.             }
  88.  
  89.         printf("\n\n               BZ Scores\n\n");
  90.         id = ( BZ & 0x00ff ) + 15 ;
  91. #if defined(BETA)
  92.         printf(    "           Beta Version %d.%d", id / 10, id % 10 ) ;
  93. #else
  94.         printf(    "              Version %d.%d", id / 10, id % 10 ) ;
  95. #endif /* defined(BETA) */
  96.  
  97.         for( k = 0 ; k < j ; k++ ) {
  98.             printf( "\n\nGame %d - ", k ) ;
  99.             if( key[k] == 0 ) {
  100.                 printf( "(no key)" ) ;
  101.                 }
  102.             else {
  103.                 if( key[k] & PRIVATE_GAME ) {
  104.                     printf( "(private game) " ) ;
  105.                     }
  106.                 else if ( key[k] & GAME_KEY_MASK ) {
  107.                     printf( "(public key = %hd) ", key[k] & GAME_KEY_MASK ) ;
  108.                     }
  109.                 if( key[k] & NO_FLAG_GAME ) {
  110.                     printf( "(no flags)" ) ;
  111.                     }
  112.                 if( key[k] & FAST_GAME ) {
  113.                     printf( "(fast game)" ) ;
  114.                     }
  115.                 }
  116.             printf( ":\n\n" ) ;
  117.                     
  118.             for( i = 1 ; i < number_players ; i++ ) {
  119.                 if( player[i].key == key[k] ) {
  120.                     addr.s_addr = player[i].id ;
  121.                     hp = gethostbyaddr( &addr, sizeof(addr), AF_INET ) ;
  122.                     printf( "%-10s  %6d  %8s  (%s)\n", player[i].name,
  123.                             player[i].score, teamName[player[i].team],
  124.                             hp ? hp->h_name : inet_ntoa(addr) ) ;
  125.                     }
  126.                 }
  127.             }
  128.         }
  129.     else {
  130.         printf("\n\nNo one is playing now.\n\n");
  131.         }
  132.     printf("\n");
  133.  
  134.     return( 0 ) ;
  135. }
  136.  
  137.  
  138.  
  139. int find_player(
  140.     long id
  141.     )
  142. {
  143.     int    i ;
  144.     int    found ;
  145.  
  146.     found = 0 ;
  147.     i = 1 ;
  148.     while( i < number_players && !found ) {
  149.         if( player[i].id == id ) found = i ;
  150.         i++ ;
  151.         }
  152.  
  153.     return(found);
  154. }
  155.  
  156.  
  157. void add_player( int *number )
  158. {
  159.     if( number_players <= MAXPLAYERS ) {
  160.         *number = number_players ;
  161.         number_players++ ;
  162.         }
  163.     else {
  164.         printf( "Maximum number (%d) of players exceeded.\n", MAXPLAYERS ) ;
  165.         exit( 0 ) ;
  166.         }
  167. }
  168.  
  169.  
  170.  
  171. void copy_player(
  172.     int k,
  173.     struct BzMember *psrc
  174.     )
  175. {
  176.     bcopy( psrc, &(player[k]), sizeof( struct BzMember ) ) ;
  177. }
  178.  
  179.  
  180.  
  181. void process_packet(
  182.     struct BzMember *input
  183.     )
  184. {
  185.     int            number ;
  186.     static int    newer = 0 ;
  187.  
  188.     if( input->bz_id == BZ ) {
  189.         /* either update existing player or create a new one */
  190.         if( !( number = find_player( input->id ) ) ) {
  191.             add_player( &number ) ;
  192.             copy_player( number, input ) ;
  193.             }
  194.         }
  195.     else if( input->bz_id == BZMSG ) {
  196.         }
  197.     else if( input->bz_id > BZ &&
  198.             ( input->bz_id & 0xffffff00 ) == (BZ & 0xffffff00) &&
  199.             newer == 0 ) {
  200.         newer = 1 ;
  201.         printf("\n\nYou are using an older version of bzwho.\n\n");
  202.         }
  203. }
  204.  
  205.  
  206.  
  207. void network_in( void )
  208. {
  209.     int                no_chars_received ;
  210.     struct BzMember    input ;
  211.     int                socket_empty = 0 ;
  212.     extern int        errno ;
  213.  
  214.     while( !socket_empty ) {
  215.         no_chars_received = recvfrom( in_fd, (char *)(&input),
  216.                                       sizeof(struct BzMember), 0, &in_addr,
  217.                                       &in_addrlen ) ;
  218.         if ( no_chars_received == sizeof(struct BzMember) ) {
  219.             process_packet( &input ) ;
  220.             }
  221.         else if( no_chars_received < 0 && errno == EWOULDBLOCK )
  222.             socket_empty = 1 ;
  223.         }
  224. }
  225.  
  226.  
  227.  
  228. static char *service_msg[] = {
  229.     "Can't find udp service \"sgi-bznet\"\n\n",
  230.     "To run bz over the network, you must have the following line\n",
  231.     "in your /etc/services file.\n\n",
  232.     "sgi-bz\t5133/udp\t\t# tank demo\n\n",
  233.     "(Using port number 5133 by default.)\n\n"
  234.     } ;
  235.  
  236.  
  237. void init_com( void )
  238. {
  239.     int    i ;
  240.     int port ;
  241.     struct servent    *serv ;
  242.  
  243.     if( ( serv = getservbyname( BZ_SERVICE, NULL ) ) == NULL ) {
  244.         for( i = 0 ; i < sizeof( service_msg ) / sizeof( service_msg[0] ) ;
  245.              i++ ) {
  246.             fputs( service_msg[i], stderr ) ;
  247.             }
  248.         port = 5133 ;
  249.         }
  250.     else {
  251.         port = serv->s_port ;
  252.         }
  253. #if defined( BETA )
  254.     port = 5134 ;
  255. #endif /* defined( BETA ) */
  256.     if( ( in_fd = openMulticastSocket( &in_addr, port, BZ_DEFAULT_TTL, 0,
  257.                     BZ_GROUP, NULL, "r" ) ) < 0 ) {
  258.     exit( 1 ) ;
  259.     }
  260.  
  261.     /*
  262.      * Turn on non-blocking I/O
  263.      */
  264.     if( fcntl( in_fd, F_SETFL, FNDELAY ) < 0 ) {
  265.         perror( "fcntl F_SETFL, FNDELAY" ) ;
  266.         exit( 1 ) ;
  267.         }
  268. }
  269.  
  270.  
  271.  
  272.